package de.thwildau.tm.moses.thrift.serializer;

import com.google.inject.Inject;
import com.google.inject.Provider;
import de.thwildau.tm.moses.thrift.services.ThriftGrammarAccess;
import de.thwildau.tm.moses.thrift.thrift.Annotation;
import de.thwildau.tm.moses.thrift.thrift.AnnotationElement;
import de.thwildau.tm.moses.thrift.thrift.BaseTypeRef;
import de.thwildau.tm.moses.thrift.thrift.BooleanRef;
import de.thwildau.tm.moses.thrift.thrift.Const;
import de.thwildau.tm.moses.thrift.thrift.ConstList;
import de.thwildau.tm.moses.thrift.thrift.ConstMap;
import de.thwildau.tm.moses.thrift.thrift.ContainerTypeRef;
import de.thwildau.tm.moses.thrift.thrift.CppInclude;
import de.thwildau.tm.moses.thrift.thrift.DefinitionRef;
import de.thwildau.tm.moses.thrift.thrift.DoubleRef;
import de.thwildau.tm.moses.thrift.thrift.EnumElement;
import de.thwildau.tm.moses.thrift.thrift.Field;
import de.thwildau.tm.moses.thrift.thrift.Function;
import de.thwildau.tm.moses.thrift.thrift.FunctionType;
import de.thwildau.tm.moses.thrift.thrift.HexRef;
import de.thwildau.tm.moses.thrift.thrift.Include;
import de.thwildau.tm.moses.thrift.thrift.ListType;
import de.thwildau.tm.moses.thrift.thrift.LongRef;
import de.thwildau.tm.moses.thrift.thrift.MapType;
import de.thwildau.tm.moses.thrift.thrift.Namespace;
import de.thwildau.tm.moses.thrift.thrift.Senum;
import de.thwildau.tm.moses.thrift.thrift.Service;
import de.thwildau.tm.moses.thrift.thrift.ServiceRef;
import de.thwildau.tm.moses.thrift.thrift.SetType;
import de.thwildau.tm.moses.thrift.thrift.StringRef;
import de.thwildau.tm.moses.thrift.thrift.Struct;
import de.thwildau.tm.moses.thrift.thrift.Thrift;
import de.thwildau.tm.moses.thrift.thrift.ThriftPackage;
import de.thwildau.tm.moses.thrift.thrift.Throws;
import de.thwildau.tm.moses.thrift.thrift.ThrowsField;
import de.thwildau.tm.moses.thrift.thrift.TypeDef;
import de.thwildau.tm.moses.thrift.thrift.Union;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.xtext.serializer.acceptor.ISemanticSequenceAcceptor;
import org.eclipse.xtext.serializer.acceptor.SequenceFeeder;
import org.eclipse.xtext.serializer.diagnostic.ISemanticSequencerDiagnosticProvider;
import org.eclipse.xtext.serializer.diagnostic.ISerializationDiagnostic.Acceptor;
import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.GenericSequencer;
import org.eclipse.xtext.serializer.sequencer.ISemanticNodeProvider.INodesForEObjectProvider;
import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient;

@SuppressWarnings("all")
public abstract class AbstractThriftSemanticSequencer extends AbstractDelegatingSemanticSequencer {

	@Inject
	private ThriftGrammarAccess grammarAccess;
	
	public void createSequence(EObject context, EObject semanticObject) {
		if(semanticObject.eClass().getEPackage() == ThriftPackage.eINSTANCE) switch(semanticObject.eClass().getClassifierID()) {
			case ThriftPackage.ANNOTATION:
				if(context == grammarAccess.getAnnotationRule()) {
					sequence_Annotation(context, (Annotation) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.ANNOTATION_ELEMENT:
				if(context == grammarAccess.getAnnotationElementRule()) {
					sequence_AnnotationElement(context, (AnnotationElement) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.BASE_TYPE_REF:
				if(context == grammarAccess.getBaseTypeRefRule() ||
				   context == grammarAccess.getDefinitionTypeRule() ||
				   context == grammarAccess.getFieldTypeRule() ||
				   context == grammarAccess.getFunctionTypeRule()) {
					sequence_BaseTypeRef(context, (BaseTypeRef) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.BOOLEAN_REF:
				if(context == grammarAccess.getBooleanRefRule() ||
				   context == grammarAccess.getConstValueRule()) {
					sequence_BooleanRef(context, (BooleanRef) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.CONST:
				if(context == grammarAccess.getConstRule() ||
				   context == grammarAccess.getDefinitionRule()) {
					sequence_Const(context, (Const) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.CONST_LIST:
				if(context == grammarAccess.getConstListRule() ||
				   context == grammarAccess.getConstValueRule()) {
					sequence_ConstList(context, (ConstList) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.CONST_MAP:
				if(context == grammarAccess.getConstMapRule() ||
				   context == grammarAccess.getConstValueRule()) {
					sequence_ConstMap(context, (ConstMap) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.CONTAINER_TYPE_REF:
				if(context == grammarAccess.getContainerTypeRefRule() ||
				   context == grammarAccess.getDefinitionTypeRule() ||
				   context == grammarAccess.getFieldTypeRule() ||
				   context == grammarAccess.getFunctionTypeRule()) {
					sequence_ContainerTypeRef(context, (ContainerTypeRef) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.CPP_INCLUDE:
				if(context == grammarAccess.getCppIncludeRule() ||
				   context == grammarAccess.getHeaderRule()) {
					sequence_CppInclude(context, (CppInclude) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.DEFINITION_REF:
				if(context == grammarAccess.getConstValueRule() ||
				   context == grammarAccess.getDefinitionRefRule() ||
				   context == grammarAccess.getFieldTypeRule() ||
				   context == grammarAccess.getFunctionTypeRule()) {
					sequence_DefinitionRef(context, (DefinitionRef) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.DOUBLE_REF:
				if(context == grammarAccess.getConstValueRule() ||
				   context == grammarAccess.getDoubleRefRule() ||
				   context == grammarAccess.getNumberRefRule()) {
					sequence_DoubleRef(context, (DoubleRef) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.ENUM:
				if(context == grammarAccess.getDefinitionRule() ||
				   context == grammarAccess.getEnumRule()) {
					sequence_Enum(context, (de.thwildau.tm.moses.thrift.thrift.Enum) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.ENUM_ELEMENT:
				if(context == grammarAccess.getEnumElementRule()) {
					sequence_EnumElement(context, (EnumElement) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.EXCEPTION:
				if(context == grammarAccess.getDefinitionRule() ||
				   context == grammarAccess.getExceptionRule()) {
					sequence_Exception(context, (de.thwildau.tm.moses.thrift.thrift.Exception) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.FIELD:
				if(context == grammarAccess.getFieldRule()) {
					sequence_Field(context, (Field) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.FUNCTION:
				if(context == grammarAccess.getFunctionRule()) {
					sequence_Function(context, (Function) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.FUNCTION_TYPE:
				if(context == grammarAccess.getFunctionTypeRule()) {
					sequence_FunctionType(context, (FunctionType) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.HEX_REF:
				if(context == grammarAccess.getConstValueRule() ||
				   context == grammarAccess.getHexRefRule() ||
				   context == grammarAccess.getNumberRefRule()) {
					sequence_HexRef(context, (HexRef) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.INCLUDE:
				if(context == grammarAccess.getHeaderRule() ||
				   context == grammarAccess.getIncludeRule()) {
					sequence_Include(context, (Include) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.LIST_TYPE:
				if(context == grammarAccess.getContainerTypeRule() ||
				   context == grammarAccess.getListTypeRule()) {
					sequence_ListType(context, (ListType) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.LONG_REF:
				if(context == grammarAccess.getConstValueRule() ||
				   context == grammarAccess.getLongRefRule() ||
				   context == grammarAccess.getNumberRefRule()) {
					sequence_LongRef(context, (LongRef) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.MAP_TYPE:
				if(context == grammarAccess.getContainerTypeRule() ||
				   context == grammarAccess.getMapTypeRule()) {
					sequence_MapType(context, (MapType) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.NAMESPACE:
				if(context == grammarAccess.getHeaderRule() ||
				   context == grammarAccess.getNamespaceRule()) {
					sequence_Namespace(context, (Namespace) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.SENUM:
				if(context == grammarAccess.getDefinitionRule() ||
				   context == grammarAccess.getSenumRule()) {
					sequence_Senum(context, (Senum) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.SERVICE:
				if(context == grammarAccess.getDefinitionRule() ||
				   context == grammarAccess.getServiceRule()) {
					sequence_Service(context, (Service) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.SERVICE_REF:
				if(context == grammarAccess.getServiceRefRule()) {
					sequence_ServiceRef(context, (ServiceRef) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.SET_TYPE:
				if(context == grammarAccess.getContainerTypeRule() ||
				   context == grammarAccess.getSetTypeRule()) {
					sequence_SetType(context, (SetType) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.STRING_REF:
				if(context == grammarAccess.getConstValueRule() ||
				   context == grammarAccess.getStringRefRule()) {
					sequence_StringRef(context, (StringRef) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.STRUCT:
				if(context == grammarAccess.getDefinitionRule() ||
				   context == grammarAccess.getStructRule()) {
					sequence_Struct(context, (Struct) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.THRIFT:
				if(context == grammarAccess.getThriftRule()) {
					sequence_Thrift(context, (Thrift) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.THROWS:
				if(context == grammarAccess.getThrowsRule()) {
					sequence_Throws(context, (Throws) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.THROWS_FIELD:
				if(context == grammarAccess.getThrowsFieldRule()) {
					sequence_ThrowsField(context, (ThrowsField) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.TYPE_DEF:
				if(context == grammarAccess.getDefinitionRule() ||
				   context == grammarAccess.getTypeDefRule()) {
					sequence_TypeDef(context, (TypeDef) semanticObject); 
					return; 
				}
				else break;
			case ThriftPackage.UNION:
				if(context == grammarAccess.getDefinitionRule() ||
				   context == grammarAccess.getUnionRule()) {
					sequence_Union(context, (Union) semanticObject); 
					return; 
				}
				else break;
			}
		if (errorAcceptor != null) errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
	}
	
	/**
	 * Constraint:
	 *     (name=QualifiedName value=STRING)
	 */
	protected void sequence_AnnotationElement(EObject context, AnnotationElement semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, ThriftPackage.Literals.ANNOTATION_ELEMENT__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ThriftPackage.Literals.ANNOTATION_ELEMENT__NAME));
			if(transientValues.isValueTransient(semanticObject, ThriftPackage.Literals.ANNOTATION_ELEMENT__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ThriftPackage.Literals.ANNOTATION_ELEMENT__VALUE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getAnnotationElementAccess().getNameQualifiedNameParserRuleCall_0_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getAnnotationElementAccess().getValueSTRINGTerminalRuleCall_2_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (elements+=AnnotationElement elements+=AnnotationElement*)
	 */
	protected void sequence_Annotation(EObject context, Annotation semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     basicType=BaseType
	 */
	protected void sequence_BaseTypeRef(EObject context, BaseTypeRef semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     boolean=BOOL
	 */
	protected void sequence_BooleanRef(EObject context, BooleanRef semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, ThriftPackage.Literals.BOOLEAN_REF__BOOLEAN) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ThriftPackage.Literals.BOOLEAN_REF__BOOLEAN));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getBooleanRefAccess().getBooleanBOOLEnumRuleCall_0(), semanticObject.getBoolean());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (value='[' | list+=ConstValue+)
	 */
	protected void sequence_ConstList(EObject context, ConstList semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (value='{' | (v1+=ConstValue v2+=ConstValue)+)
	 */
	protected void sequence_ConstMap(EObject context, ConstMap semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (type=FieldType name=ID value=ConstValue)
	 */
	protected void sequence_Const(EObject context, Const semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, ThriftPackage.Literals.DEFINITION__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ThriftPackage.Literals.DEFINITION__NAME));
			if(transientValues.isValueTransient(semanticObject, ThriftPackage.Literals.CONST__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ThriftPackage.Literals.CONST__TYPE));
			if(transientValues.isValueTransient(semanticObject, ThriftPackage.Literals.CONST__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ThriftPackage.Literals.CONST__VALUE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getConstAccess().getTypeFieldTypeParserRuleCall_1_0(), semanticObject.getType());
		feeder.accept(grammarAccess.getConstAccess().getNameIDTerminalRuleCall_2_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getConstAccess().getValueConstValueParserRuleCall_4_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     containerType=ContainerType
	 */
	protected void sequence_ContainerTypeRef(EObject context, ContainerTypeRef semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     importURI=STRING
	 */
	protected void sequence_CppInclude(EObject context, CppInclude semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, ThriftPackage.Literals.CPP_INCLUDE__IMPORT_URI) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ThriftPackage.Literals.CPP_INCLUDE__IMPORT_URI));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getCppIncludeAccess().getImportURISTRINGTerminalRuleCall_1_0(), semanticObject.getImportURI());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     definition=[Definition|QualifiedName]
	 */
	protected void sequence_DefinitionRef(EObject context, DefinitionRef semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     double=DOUBLE
	 */
	protected void sequence_DoubleRef(EObject context, DoubleRef semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, ThriftPackage.Literals.DOUBLE_REF__DOUBLE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ThriftPackage.Literals.DOUBLE_REF__DOUBLE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getDoubleRefAccess().getDoubleDOUBLETerminalRuleCall_0(), semanticObject.getDouble());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID value=LONG?)
	 */
	protected void sequence_EnumElement(EObject context, EnumElement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID elements+=EnumElement*)
	 */
	protected void sequence_Enum(EObject context, de.thwildau.tm.moses.thrift.thrift.Enum semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID fields+=Field*)
	 */
	protected void sequence_Exception(EObject context, de.thwildau.tm.moses.thrift.thrift.Exception semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         fieldId=FieldID? 
	 *         fieldReq=FieldReq? 
	 *         type=FieldType 
	 *         name=ID 
	 *         value=ConstValue? 
	 *         annotation=Annotation? 
	 *         fields+=Field*
	 *     )
	 */
	protected void sequence_Field(EObject context, Field semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (oneway='oneway'? type='void')
	 */
	protected void sequence_FunctionType(EObject context, FunctionType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (functionType=FunctionType name=ID fields+=Field* throwsDecl=Throws?)
	 */
	protected void sequence_Function(EObject context, Function semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     hex=HEX
	 */
	protected void sequence_HexRef(EObject context, HexRef semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, ThriftPackage.Literals.HEX_REF__HEX) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ThriftPackage.Literals.HEX_REF__HEX));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getHexRefAccess().getHexHEXTerminalRuleCall_0(), semanticObject.getHex());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     importURI=STRING
	 */
	protected void sequence_Include(EObject context, Include semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, ThriftPackage.Literals.INCLUDE__IMPORT_URI) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ThriftPackage.Literals.INCLUDE__IMPORT_URI));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getIncludeAccess().getImportURISTRINGTerminalRuleCall_1_0(), semanticObject.getImportURI());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (listType=FieldType listTypeAnnotation=Annotation? cppType=CppType?)
	 */
	protected void sequence_ListType(EObject context, ListType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     long=LONG
	 */
	protected void sequence_LongRef(EObject context, LongRef semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, ThriftPackage.Literals.LONG_REF__LONG) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ThriftPackage.Literals.LONG_REF__LONG));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getLongRefAccess().getLongLONGTerminalRuleCall_0(), semanticObject.getLong());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (cppType=CppType? mapType1=FieldType mapType1Annotation=Annotation? mapType2=FieldType mapType2Annotation=Annotation?)
	 */
	protected void sequence_MapType(EObject context, MapType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (((namespaceScope='*' | namespaceScope=QualifiedName) namespaceURI=QualifiedName) | namespaceURI=STRING | namespaceURI=STRING)
	 */
	protected void sequence_Namespace(EObject context, Namespace semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID elements+=STRING*)
	 */
	protected void sequence_Senum(EObject context, Senum semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     service=[Service|QualifiedName]
	 */
	protected void sequence_ServiceRef(EObject context, ServiceRef semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, ThriftPackage.Literals.SERVICE_REF__SERVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ThriftPackage.Literals.SERVICE_REF__SERVICE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getServiceRefAccess().getServiceServiceQualifiedNameParserRuleCall_0_1(), semanticObject.getService());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID superType=ServiceRef? functions+=Function*)
	 */
	protected void sequence_Service(EObject context, Service semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (cppType=CppType? setType=FieldType setTypeAnnotation=Annotation?)
	 */
	protected void sequence_SetType(EObject context, SetType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     string=STRING
	 */
	protected void sequence_StringRef(EObject context, StringRef semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, ThriftPackage.Literals.STRING_REF__STRING) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ThriftPackage.Literals.STRING_REF__STRING));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getStringRefAccess().getStringSTRINGTerminalRuleCall_0(), semanticObject.getString());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID fields+=Field* annotation=Annotation?)
	 */
	protected void sequence_Struct(EObject context, Struct semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (headers+=Header* definitions+=Definition*)
	 */
	protected void sequence_Thrift(EObject context, Thrift semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (fieldId=FieldID? type=[Exception|ID] name=ID)
	 */
	protected void sequence_ThrowsField(EObject context, ThrowsField semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (fields+=ThrowsField fields+=ThrowsField*)
	 */
	protected void sequence_Throws(EObject context, Throws semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (type=DefinitionType annotation=Annotation? name=ID)
	 */
	protected void sequence_TypeDef(EObject context, TypeDef semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID fields+=Field* annotation=Annotation?)
	 */
	protected void sequence_Union(EObject context, Union semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
}
